// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.supplier.flow.node;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.SupplierFlowNode;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(SupplierFlowNode.class)
@Setter
@Getter
public class SupplierFlowNodeSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "SupplierFlowNode".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("nodeDoUser", "su");
    map.put("nodeDoRole", "sr");
    map.put("nodeDoDepartment", "sd");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 流程编码(模糊搜索)
   */
  private String enCode;

  /**
   * 流程编码 比较(eq)
   */
  private String enCodeEq;
  /**
   * 流程编码 比较(neq)
   */
  private String enCodeNeq;
  /**
   * 流程编码 比较(gt)
   */
  private String enCodeGt;
  /**
   * 流程编码 比较(gte)
   */
  private String enCodeGte;
  /**
   * 流程编码 比较(lt)
   */
  private String enCodeLt;
  /**
   * 流程编码 比较(lte)
   */
  private String enCodeLte;
  /**
   * 流程编码 比较(contains)
   */
  private String enCodeContains;
  /**
   * 流程编码 比较(notcontains)
   */
  private String enCodeNotcontains;
  /**
   * 流程编码 比较(startswith)
   */
  private String enCodeStartswith;
  /**
   * 流程编码 比较(endswith)
   */
  private String enCodeEndswith;
  /**
   * 流程编码 比较(isnull)
   */
  private Boolean enCodeIsnull;
  /**
   * 流程编码 比较(isnotnull)
   */
  private Boolean enCodeIsnotnull;

  /**
   * 流程编码(精确搜索)
   */
  private List<String> enCodeInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 节点类型
   */
  private String type;

  /**
   * 节点类型 比较(eq)
   */
  private String typeEq;
  /**
   * 节点类型 比较(neq)
   */
  private String typeNeq;
  /**
   * 节点类型 比较(gt)
   */
  private String typeGt;
  /**
   * 节点类型 比较(gte)
   */
  private String typeGte;
  /**
   * 节点类型 比较(lt)
   */
  private String typeLt;
  /**
   * 节点类型 比较(lte)
   */
  private String typeLte;
  /**
   * 节点类型 比较(contains)
   */
  private String typeContains;
  /**
   * 节点类型 比较(notcontains)
   */
  private String typeNotcontains;
  /**
   * 节点类型 比较(startswith)
   */
  private String typeStartswith;
  /**
   * 节点类型 比较(endswith)
   */
  private String typeEndswith;
  /**
   * 节点类型 比较(isnull)
   */
  private Boolean typeIsnull;
  /**
   * 节点类型 比较(isnotnull)
   */
  private Boolean typeIsnotnull;

  /**
   * 节点类型(精确搜索)
   */
  private List<String> typeInList;

  /**
   * 当前节点
   */
  private String nodeUp;

  /**
   * 当前节点 比较(eq)
   */
  private String nodeUpEq;
  /**
   * 当前节点 比较(neq)
   */
  private String nodeUpNeq;
  /**
   * 当前节点 比较(gt)
   */
  private String nodeUpGt;
  /**
   * 当前节点 比较(gte)
   */
  private String nodeUpGte;
  /**
   * 当前节点 比较(lt)
   */
  private String nodeUpLt;
  /**
   * 当前节点 比较(lte)
   */
  private String nodeUpLte;
  /**
   * 当前节点 比较(contains)
   */
  private String nodeUpContains;
  /**
   * 当前节点 比较(notcontains)
   */
  private String nodeUpNotcontains;
  /**
   * 当前节点 比较(startswith)
   */
  private String nodeUpStartswith;
  /**
   * 当前节点 比较(endswith)
   */
  private String nodeUpEndswith;
  /**
   * 当前节点 比较(isnull)
   */
  private Boolean nodeUpIsnull;
  /**
   * 当前节点 比较(isnotnull)
   */
  private Boolean nodeUpIsnotnull;

  /**
   * 当前节点(精确搜索)
   */
  private List<String> nodeUpInList;

  /**
   * 目标节点
   */
  private String node;

  /**
   * 目标节点 比较(eq)
   */
  private String nodeEq;
  /**
   * 目标节点 比较(neq)
   */
  private String nodeNeq;
  /**
   * 目标节点 比较(gt)
   */
  private String nodeGt;
  /**
   * 目标节点 比较(gte)
   */
  private String nodeGte;
  /**
   * 目标节点 比较(lt)
   */
  private String nodeLt;
  /**
   * 目标节点 比较(lte)
   */
  private String nodeLte;
  /**
   * 目标节点 比较(contains)
   */
  private String nodeContains;
  /**
   * 目标节点 比较(notcontains)
   */
  private String nodeNotcontains;
  /**
   * 目标节点 比较(startswith)
   */
  private String nodeStartswith;
  /**
   * 目标节点 比较(endswith)
   */
  private String nodeEndswith;
  /**
   * 目标节点 比较(isnull)
   */
  private Boolean nodeIsnull;
  /**
   * 目标节点 比较(isnotnull)
   */
  private Boolean nodeIsnotnull;

  /**
   * 目标节点(精确搜索)
   */
  private List<String> nodeInList;

  /**
   * 异常节点
   */
  private String nodeExceptionStatus;

  /**
   * 异常节点 比较(eq)
   */
  private String nodeExceptionStatusEq;
  /**
   * 异常节点 比较(neq)
   */
  private String nodeExceptionStatusNeq;
  /**
   * 异常节点 比较(gt)
   */
  private String nodeExceptionStatusGt;
  /**
   * 异常节点 比较(gte)
   */
  private String nodeExceptionStatusGte;
  /**
   * 异常节点 比较(lt)
   */
  private String nodeExceptionStatusLt;
  /**
   * 异常节点 比较(lte)
   */
  private String nodeExceptionStatusLte;
  /**
   * 异常节点 比较(contains)
   */
  private String nodeExceptionStatusContains;
  /**
   * 异常节点 比较(notcontains)
   */
  private String nodeExceptionStatusNotcontains;
  /**
   * 异常节点 比较(startswith)
   */
  private String nodeExceptionStatusStartswith;
  /**
   * 异常节点 比较(endswith)
   */
  private String nodeExceptionStatusEndswith;
  /**
   * 异常节点 比较(isnull)
   */
  private Boolean nodeExceptionStatusIsnull;
  /**
   * 异常节点 比较(isnotnull)
   */
  private Boolean nodeExceptionStatusIsnotnull;

  /**
   * 异常节点(精确搜索)
   */
  private List<String> nodeExceptionStatusInList;

  /**
   * 异常下游节点
   */
  private String nodeDownExceptionStatus;

  /**
   * 异常下游节点 比较(eq)
   */
  private String nodeDownExceptionStatusEq;
  /**
   * 异常下游节点 比较(neq)
   */
  private String nodeDownExceptionStatusNeq;
  /**
   * 异常下游节点 比较(gt)
   */
  private String nodeDownExceptionStatusGt;
  /**
   * 异常下游节点 比较(gte)
   */
  private String nodeDownExceptionStatusGte;
  /**
   * 异常下游节点 比较(lt)
   */
  private String nodeDownExceptionStatusLt;
  /**
   * 异常下游节点 比较(lte)
   */
  private String nodeDownExceptionStatusLte;
  /**
   * 异常下游节点 比较(contains)
   */
  private String nodeDownExceptionStatusContains;
  /**
   * 异常下游节点 比较(notcontains)
   */
  private String nodeDownExceptionStatusNotcontains;
  /**
   * 异常下游节点 比较(startswith)
   */
  private String nodeDownExceptionStatusStartswith;
  /**
   * 异常下游节点 比较(endswith)
   */
  private String nodeDownExceptionStatusEndswith;
  /**
   * 异常下游节点 比较(isnull)
   */
  private Boolean nodeDownExceptionStatusIsnull;
  /**
   * 异常下游节点 比较(isnotnull)
   */
  private Boolean nodeDownExceptionStatusIsnotnull;

  /**
   * 异常下游节点(精确搜索)
   */
  private List<String> nodeDownExceptionStatusInList;

  /**
   * 任务拾取人
   */
  private String toUserField;

  /**
   * 任务拾取人 比较(eq)
   */
  private String toUserFieldEq;
  /**
   * 任务拾取人 比较(neq)
   */
  private String toUserFieldNeq;
  /**
   * 任务拾取人 比较(gt)
   */
  private String toUserFieldGt;
  /**
   * 任务拾取人 比较(gte)
   */
  private String toUserFieldGte;
  /**
   * 任务拾取人 比较(lt)
   */
  private String toUserFieldLt;
  /**
   * 任务拾取人 比较(lte)
   */
  private String toUserFieldLte;
  /**
   * 任务拾取人 比较(contains)
   */
  private String toUserFieldContains;
  /**
   * 任务拾取人 比较(notcontains)
   */
  private String toUserFieldNotcontains;
  /**
   * 任务拾取人 比较(startswith)
   */
  private String toUserFieldStartswith;
  /**
   * 任务拾取人 比较(endswith)
   */
  private String toUserFieldEndswith;
  /**
   * 任务拾取人 比较(isnull)
   */
  private Boolean toUserFieldIsnull;
  /**
   * 任务拾取人 比较(isnotnull)
   */
  private Boolean toUserFieldIsnotnull;

  /**
   * 任务拾取人(精确搜索)
   */
  private List<String> toUserFieldInList;

  /**
   * 任务待转发人
   */
  private String forwardUserField;

  /**
   * 任务待转发人 比较(eq)
   */
  private String forwardUserFieldEq;
  /**
   * 任务待转发人 比较(neq)
   */
  private String forwardUserFieldNeq;
  /**
   * 任务待转发人 比较(gt)
   */
  private String forwardUserFieldGt;
  /**
   * 任务待转发人 比较(gte)
   */
  private String forwardUserFieldGte;
  /**
   * 任务待转发人 比较(lt)
   */
  private String forwardUserFieldLt;
  /**
   * 任务待转发人 比较(lte)
   */
  private String forwardUserFieldLte;
  /**
   * 任务待转发人 比较(contains)
   */
  private String forwardUserFieldContains;
  /**
   * 任务待转发人 比较(notcontains)
   */
  private String forwardUserFieldNotcontains;
  /**
   * 任务待转发人 比较(startswith)
   */
  private String forwardUserFieldStartswith;
  /**
   * 任务待转发人 比较(endswith)
   */
  private String forwardUserFieldEndswith;
  /**
   * 任务待转发人 比较(isnull)
   */
  private Boolean forwardUserFieldIsnull;
  /**
   * 任务待转发人 比较(isnotnull)
   */
  private Boolean forwardUserFieldIsnotnull;

  /**
   * 任务待转发人(精确搜索)
   */
  private List<String> forwardUserFieldInList;

  /**
   * 候选人
   */
  private Long nodeDoUser;

  /**
   * 候选人 比较(eq)
   */
  private Long nodeDoUserEq;
  /**
   * 候选人 比较(neq)
   */
  private Long nodeDoUserNeq;
  /**
   * 候选人 比较(gt)
   */
  private Long nodeDoUserGt;
  /**
   * 候选人 比较(gte)
   */
  private Long nodeDoUserGte;
  /**
   * 候选人 比较(lt)
   */
  private Long nodeDoUserLt;
  /**
   * 候选人 比较(lte)
   */
  private Long nodeDoUserLte;
  /**
   * 候选人 比较(contains)
   */
  private Long nodeDoUserContains;
  /**
   * 候选人 比较(notcontains)
   */
  private Long nodeDoUserNotcontains;
  /**
   * 候选人 比较(startswith)
   */
  private Long nodeDoUserStartswith;
  /**
   * 候选人 比较(endswith)
   */
  private Long nodeDoUserEndswith;
  /**
   * 候选人 比较(isnull)
   */
  private Boolean nodeDoUserIsnull;
  /**
   * 候选人 比较(isnotnull)
   */
  private Boolean nodeDoUserIsnotnull;
  /**
   * 候选人的显示用户名 比较(eq)
   */
  private String nodeDoUserNameEq;
  /**
   * 候选人的显示用户名 比较(neq)
   */
  private String nodeDoUserNameNeq;
  /**
   * 候选人的显示用户名 比较(gt)
   */
  private String nodeDoUserNameGt;
  /**
   * 候选人的显示用户名 比较(gte)
   */
  private String nodeDoUserNameGte;
  /**
   * 候选人的显示用户名 比较(lt)
   */
  private String nodeDoUserNameLt;
  /**
   * 候选人的显示用户名 比较(lte)
   */
  private String nodeDoUserNameLte;
  /**
   * 候选人的显示用户名 比较(contains)
   */
  private String nodeDoUserNameContains;
  /**
   * 候选人的显示用户名 比较(notcontains)
   */
  private String nodeDoUserNameNotcontains;
  /**
   * 候选人的显示用户名 比较(startswith)
   */
  private String nodeDoUserNameStartswith;
  /**
   * 候选人的显示用户名 比较(endswith)
   */
  private String nodeDoUserNameEndswith;
  /**
   * 候选人的显示用户名 比较(isnull)
   */
  private Boolean nodeDoUserNameIsnull;
  /**
   * 候选人的显示用户名 比较(isnotnull)
   */
  private Boolean nodeDoUserNameIsnotnull;

  /**
   * 候选人(范围搜索)
   */
  private List<Long> nodeDoUserInList;

  /**
   * 候选角色
   */
  private Long nodeDoRole;

  /**
   * 候选角色 比较(eq)
   */
  private Long nodeDoRoleEq;
  /**
   * 候选角色 比较(neq)
   */
  private Long nodeDoRoleNeq;
  /**
   * 候选角色 比较(gt)
   */
  private Long nodeDoRoleGt;
  /**
   * 候选角色 比较(gte)
   */
  private Long nodeDoRoleGte;
  /**
   * 候选角色 比较(lt)
   */
  private Long nodeDoRoleLt;
  /**
   * 候选角色 比较(lte)
   */
  private Long nodeDoRoleLte;
  /**
   * 候选角色 比较(contains)
   */
  private Long nodeDoRoleContains;
  /**
   * 候选角色 比较(notcontains)
   */
  private Long nodeDoRoleNotcontains;
  /**
   * 候选角色 比较(startswith)
   */
  private Long nodeDoRoleStartswith;
  /**
   * 候选角色 比较(endswith)
   */
  private Long nodeDoRoleEndswith;
  /**
   * 候选角色 比较(isnull)
   */
  private Boolean nodeDoRoleIsnull;
  /**
   * 候选角色 比较(isnotnull)
   */
  private Boolean nodeDoRoleIsnotnull;
  /**
   * 候选角色的角色名称 比较(eq)
   */
  private String nodeDoRoleRoleNameEq;
  /**
   * 候选角色的角色名称 比较(neq)
   */
  private String nodeDoRoleRoleNameNeq;
  /**
   * 候选角色的角色名称 比较(gt)
   */
  private String nodeDoRoleRoleNameGt;
  /**
   * 候选角色的角色名称 比较(gte)
   */
  private String nodeDoRoleRoleNameGte;
  /**
   * 候选角色的角色名称 比较(lt)
   */
  private String nodeDoRoleRoleNameLt;
  /**
   * 候选角色的角色名称 比较(lte)
   */
  private String nodeDoRoleRoleNameLte;
  /**
   * 候选角色的角色名称 比较(contains)
   */
  private String nodeDoRoleRoleNameContains;
  /**
   * 候选角色的角色名称 比较(notcontains)
   */
  private String nodeDoRoleRoleNameNotcontains;
  /**
   * 候选角色的角色名称 比较(startswith)
   */
  private String nodeDoRoleRoleNameStartswith;
  /**
   * 候选角色的角色名称 比较(endswith)
   */
  private String nodeDoRoleRoleNameEndswith;
  /**
   * 候选角色的角色名称 比较(isnull)
   */
  private Boolean nodeDoRoleRoleNameIsnull;
  /**
   * 候选角色的角色名称 比较(isnotnull)
   */
  private Boolean nodeDoRoleRoleNameIsnotnull;

  /**
   * 候选角色(范围搜索)
   */
  private List<Long> nodeDoRoleInList;

  /**
   * 候选组织(备用)
   */
  private Long nodeDoDepartment;

  /**
   * 候选组织(备用) 比较(eq)
   */
  private Long nodeDoDepartmentEq;
  /**
   * 候选组织(备用) 比较(neq)
   */
  private Long nodeDoDepartmentNeq;
  /**
   * 候选组织(备用) 比较(gt)
   */
  private Long nodeDoDepartmentGt;
  /**
   * 候选组织(备用) 比较(gte)
   */
  private Long nodeDoDepartmentGte;
  /**
   * 候选组织(备用) 比较(lt)
   */
  private Long nodeDoDepartmentLt;
  /**
   * 候选组织(备用) 比较(lte)
   */
  private Long nodeDoDepartmentLte;
  /**
   * 候选组织(备用) 比较(contains)
   */
  private Long nodeDoDepartmentContains;
  /**
   * 候选组织(备用) 比较(notcontains)
   */
  private Long nodeDoDepartmentNotcontains;
  /**
   * 候选组织(备用) 比较(startswith)
   */
  private Long nodeDoDepartmentStartswith;
  /**
   * 候选组织(备用) 比较(endswith)
   */
  private Long nodeDoDepartmentEndswith;
  /**
   * 候选组织(备用) 比较(isnull)
   */
  private Boolean nodeDoDepartmentIsnull;
  /**
   * 候选组织(备用) 比较(isnotnull)
   */
  private Boolean nodeDoDepartmentIsnotnull;
  /**
   * 候选组织(备用)的部门名称 比较(eq)
   */
  private String nodeDoDepartmentNameEq;
  /**
   * 候选组织(备用)的部门名称 比较(neq)
   */
  private String nodeDoDepartmentNameNeq;
  /**
   * 候选组织(备用)的部门名称 比较(gt)
   */
  private String nodeDoDepartmentNameGt;
  /**
   * 候选组织(备用)的部门名称 比较(gte)
   */
  private String nodeDoDepartmentNameGte;
  /**
   * 候选组织(备用)的部门名称 比较(lt)
   */
  private String nodeDoDepartmentNameLt;
  /**
   * 候选组织(备用)的部门名称 比较(lte)
   */
  private String nodeDoDepartmentNameLte;
  /**
   * 候选组织(备用)的部门名称 比较(contains)
   */
  private String nodeDoDepartmentNameContains;
  /**
   * 候选组织(备用)的部门名称 比较(notcontains)
   */
  private String nodeDoDepartmentNameNotcontains;
  /**
   * 候选组织(备用)的部门名称 比较(startswith)
   */
  private String nodeDoDepartmentNameStartswith;
  /**
   * 候选组织(备用)的部门名称 比较(endswith)
   */
  private String nodeDoDepartmentNameEndswith;
  /**
   * 候选组织(备用)的部门名称 比较(isnull)
   */
  private Boolean nodeDoDepartmentNameIsnull;
  /**
   * 候选组织(备用)的部门名称 比较(isnotnull)
   */
  private Boolean nodeDoDepartmentNameIsnotnull;

  /**
   * 候选组织(备用)(范围搜索)
   */
  private List<Long> nodeDoDepartmentInList;

  /**
   * 顺序
   */
  private Integer nodeSort;

  /**
   * 最小顺序
   */
  private Integer nodeSortMin;

  /**
   * 最大顺序
   */
  private Integer nodeSortMax;

  /**
   * 顺序 比较(eq)
   */
  private Integer nodeSortEq;
  /**
   * 顺序 比较(neq)
   */
  private Integer nodeSortNeq;
  /**
   * 顺序 比较(gt)
   */
  private Integer nodeSortGt;
  /**
   * 顺序 比较(gte)
   */
  private Integer nodeSortGte;
  /**
   * 顺序 比较(lt)
   */
  private Integer nodeSortLt;
  /**
   * 顺序 比较(lte)
   */
  private Integer nodeSortLte;
  /**
   * 顺序 比较(contains)
   */
  private Integer nodeSortContains;
  /**
   * 顺序 比较(notcontains)
   */
  private Integer nodeSortNotcontains;
  /**
   * 顺序 比较(startswith)
   */
  private Integer nodeSortStartswith;
  /**
   * 顺序 比较(endswith)
   */
  private Integer nodeSortEndswith;
  /**
   * 顺序 比较(isnull)
   */
  private Boolean nodeSortIsnull;
  /**
   * 顺序 比较(isnotnull)
   */
  private Boolean nodeSortIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
